import jdk.nashorn.internal.runtime.regexp.joni.ast.StringNode;


import java.util.*;

public class Test {

    public static void main(String[] args) {
        HashMap<Character, Integer> map = new HashMap<>();
        map.put('a',1);
        map.put('b',2);
        map.put('a',map.getOrDefault('2',1)+1);
        System.out.println(map.get('a'));
    }


















/*给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
* */
    public static boolean isValid(String s) {
        Stack stack = new Stack();

        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);

            if (ch == '{' || ch == '(' || ch == '['){
                stack.push(ch);
            }else if(s.charAt(i) == ')'){
                if (stack.peek() == ")"){
                    stack.pop();
                }
            }else if(ch == '}'){
                if (stack.peek() == "}"){
                    stack.pop();
                }
            }else if(s.charAt(i) == ']'){
                if (stack.peek() == "]"){
                    stack.pop();
                }
            }

        }
        boolean result = false;
        if (stack.size() == 0){
            result = true;
        }
        return result;

    }

//给你两个整数数组 nums1 和 nums2 ，
// 请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，
// 应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）
// 。可以不考虑输出结果的顺序。
public int[] intersect(int[] nums1, int[] nums2) {
    List<Integer> list  = new ArrayList<>();
    int num = 0;

    HashSet<Integer> set = new HashSet<>();
    for (int i = 0; i < nums2.length; i++) {
        set.add(nums2[i]);
    }

    for (int i = 0; i < nums1.length; i++) {
        if (set.contains(nums1[i])){
            list.add(nums1[i]);
        }
    }
    int[] result = new int[list.size()];
    for (int i = 0; i < list.size(); i++) {
        result[i] = list.get(i);
    }
    return result;


}



    //把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
//给你一个可能存在重复元素值的数组numbers
// ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。
// 例如，数组[3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为1。
    public int minArray(int[] numbers) {
        int size = numbers.length;

        int min = numbers[0];
        for (int i = 1; i < size; i++) {
            if (numbers[i] < min){
                min = numbers[i];
            }
        }
        return min;
    }

    /*public int minArray(int[] numbers) {
        int left = 0,right = right =numbers.length,mid = (left + right)/2;
        //第一步找到断点



    }
    public int temp(int numbers[],int left,int right){
        int mid = (left + right)/2;
        if (numbers[mid] <= numbers[mid-1] && numbers[mid] <= numbers[mid + 1]){
            return mid;
        }else if (numbers[mid]){

        }
    }*/
    public static char firstUniqChar(String s) {
        LinkedHashMap<Character, Integer> map = new LinkedHashMap<>();
        for (int i = 0; i < s.length(); i++) {
            if (!map.containsKey(s.charAt(i))){
                map.put(s.charAt(i),1);
            }else {
                map.put(s.charAt(i),map.get(s.charAt(i))+1);
            }
        }
        System.out.println(map);


        char result = 0;
        Set<Map.Entry<Character, Integer>> set = map.entrySet();
        for (Map.Entry<Character, Integer> entry : set) {
            if (entry.getValue() == 1){
                result = entry.getKey();
                break;
            }
        }
        return result;
    }

    public static int removeDuplicates(int[] nums) {
        int result= 0;
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            int j = i;
            while (set.contains(nums[j]) && j<nums.length){

            }
        }
        return result;
    }





    public static  int bin(int[] nums,int left,int right){
        int mid = (left + right)/2;
        int temp = nums[mid];
        int result = 0;
        if (left > right){
            return 0;
        }
        if(temp >= nums[temp + 1] && temp <= nums[temp-1]){
            //找到该数据
            result = temp;
        }
        return 0;
    }


    //一个长度为n-1的递增排序数组中的所有数字都是唯一的，
    // 并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中
    // ，请找出这个数字。
    // 输入: [0,1,3]
    //输出: 2
    public int missingNumber(int[] nums){

        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            set.add(nums[i]);
        }

        int result = 0;
        for (int i = 0; i < nums.length-1; i++) {
            if (!set.contains(i)){
                result = i;
            }
        }

        return result;
    }













    //二分查找
    public static int searchLearn(int[] nums,int left,int right,int target){
        if (left>right){
            return -1;
        }
        int mid = (left+right)/2;
        if (target>nums[mid]){
            //递归右边
            return searchLearn(nums, mid+1, right, target);
        }else if(target<nums[mid]){
            //向左递归
            return searchLearn(nums, left, mid-1, target);
        }else{
            return mid;
        }

    }

    //左旋转
    public String reverseLeftWords(String s, int n) {
        StringBuilder builder = new StringBuilder();
        for (int i = n; i < s.length(); i++) {
            builder.append(s.charAt(i));
        }
        for (int i = 0; i < n; i++) {
            builder.append(s.charAt(i));
        }
        return String.valueOf(builder);
    }
    //找出数组中重复的数字
    public int findRepeatNumber(int[] nums) {
        HashSet<Integer> set = new HashSet<>();

        for (int i = 0; i < nums.length; i++) {
            boolean add = set.add(nums[i]);
            if (!add){
                return nums[i];
            }
        }
        throw new RuntimeException("无重复数据");
    }
    //统计一个数字在数组中出现几次
    public int search(int[] nums, int target) {
      /*  HashSet<Integer> set = new HashSet<>();
        set.add(target);
        int result = 0;

        for (int num : nums) {
            boolean contains = set.contains(num);
            if (contains){
                result++;
            }
        }
        return result;*/
        //用二分查找来做




        return temp(nums,0,nums.length-1,target);
    }
    public int temp(int[] nums,int left,int right,int target){
        ArrayList<Integer> list = new ArrayList<>();
        if (left > right){
            return -1;
        }
        int mid = (left+right)/2;
        if (target > nums[mid]){
            return temp(nums, mid+1, right, target);
        }else if (target < nums[mid]){
            return temp( nums, left, mid -1, target);
        }else {
            list.add(mid);
            int temp = mid-1;
            while(temp !=0 || nums[temp] == target){
                list.add(temp);
                temp--;
            }
            int temp1 = mid +1;
            while(temp1 <= right || nums[temp1] == target){
                list.add(temp1);
                temp1++;
            }
            return list.size();
        }
    }
    //一个长度为n-1的递增排序数组中的所有数字都是唯一的，
    // 并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

    public int missingNumbers(int[] nums) {
        int result = 0;
        for (int i = nums[0]; i < nums[nums.length-1]; i++) {
            if (i!=nums[i]){
                result = i;
            }
        }
        return result;
    }
}
